package com.lianyu.wangyiyun.utils;


import android.util.Log;

import com.lianyu.wangyiyun.fragment.LyricFragment;
import com.lianyu.wangyiyun.fragment.RecommendFragment;
import com.lianyu.wangyiyun.fragment.SearchFragment;
import com.lianyu.wangyiyun.model.CloudMusic;
import com.lianyu.wangyiyun.model.Lyric;
import com.lianyu.wangyiyun.model.Mp3Info;
import com.lianyu.wangyiyun.model.PlayListInfo;
import com.scwang.smart.refresh.layout.api.RefreshLayout;
import com.scwang.smart.refresh.layout.constant.RefreshState;

import java.util.List;

import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.core.Observer;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.schedulers.Schedulers;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava3.RxJava3CallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;
import retrofit2.http.GET;
import retrofit2.http.Query;

/**
 * @author Chen Yuguang
 */
public class MyRetrofit {
    private static final String TAG = "MyRetrofit";

    public interface GetRequestInterface {
        /**
         * 网易云单曲搜索网络请求接口
         *
         * @param song   歌名关键词
         * @param offset 偏移值
         * @return io.reactivex.rxjava3.core.Observable<com.lianyu.wangyiyun.model.CloudMusic>
         * @author Chen Yuguang
         * @date 2021/5/16 4:48
         */
        @GET("/api/cloudsearch/pc?limit=30&type=1")
        Observable<CloudMusic> getCall(@Query("s") String song, @Query("offset") int offset);
        // 注解里传入 网络请求 的部分URL地址
        // Retrofit把网络请求的URL分成了两部分：一部分放在Retrofit对象里，另一部分放在网络请求接口里
        // 如果接口里的url是一个完整的网址，那么放在Retrofit对象里的URL可以忽略
        // 采用Observable<...>接口
        // getCall()是接受网络请求数据的方法
    }

    /**
     * 网易云单曲搜索网络请求方法
     *
     * @param searchFragment 搜索视图片段
     * @param song           歌名关键词
     * @param offset         偏移值
     * @author Chen Yuguang
     * @date 2021/5/16 4:50
     */
    public static void get(@NonNull SearchFragment searchFragment, String song, int offset) {

        // 创建Retrofit对象
        Retrofit retrofit = new Retrofit.Builder()
                // 设置 网络请求 Url
                .baseUrl("https://music.163.com/")
                //设置使用Gson解析(记得加入依赖)
                .addConverterFactory(GsonConverterFactory.create())
                // 支持RxJava
                .addCallAdapterFactory(RxJava3CallAdapterFactory.create())
                .build();

        // 创建 网络请求接口 的实例
        GetRequestInterface request = retrofit.create(GetRequestInterface.class);
        // 采用Observable<...>形式 对 网络请求 进行封装
        Observable<CloudMusic> observable = request.getCall(song, offset);

        // 发送网络请求
        // 在IO线程进行网络请求
        observable.subscribeOn(Schedulers.io())
                // 回到主线程 处理请求结果
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<CloudMusic>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                        Log.d(TAG, "开始采用网易云单曲搜索接口连接");
                    }

                    @Override
                    public void onNext(@NonNull CloudMusic result) {
                        // 对返回的数据进行处理
                        if (offset == 0) {
                            searchFragment.setList(result.cloud2local());
                        } else {
                            searchFragment.addList(result.cloud2local());
                        }
                        RefreshLayout refreshLayout = searchFragment.getRefreshLayout();
                        if (refreshLayout != null) {
                            if (refreshLayout.getState() == RefreshState.Refreshing) {
                                refreshLayout.finishRefresh();
                            } else if (refreshLayout.getState() == RefreshState.Loading) {
                                refreshLayout.finishLoadMore();
                            }
                        }
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {
                        Log.d(TAG, "请求失败：" + e.getMessage(), e);
                        RefreshLayout refreshLayout = searchFragment.getRefreshLayout();
                        if (refreshLayout != null) {
                            if (refreshLayout.getState() == RefreshState.Refreshing) {
                                refreshLayout.finishRefresh(false);
                            } else if (refreshLayout.getState() == RefreshState.Loading) {
                                refreshLayout.finishLoadMore(false);
                            }
                        }
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "请求成功");
                    }
                });

    }

    public interface GetRequestInterface2 {
        /**
         * 网易云推荐歌单详情网络请求接口
         *
         * @return io.reactivex.rxjava3.core.Observable<com.lianyu.wangyiyun.model.PlayListInfo>
         * @author Chen Yuguang
         * @date 2021/5/16 4:48
         */
        @GET("/api/v6/playlist/detail?id=3778678&n=100000&s=0")
        Observable<PlayListInfo> getCall();
        // 注解里传入 网络请求 的部分URL地址
        // Retrofit把网络请求的URL分成了两部分：一部分放在Retrofit对象里，另一部分放在网络请求接口里
        // 如果接口里的url是一个完整的网址，那么放在Retrofit对象里的URL可以忽略
        // 采用Observable<...>接口
        // getCall()是接受网络请求数据的方法
    }

    /**
     * 网易云推荐歌单详情网络请求方法
     *
     * @param recommendFragment 推荐视图片段
     * @author Chen Yuguang
     * @date 2021/5/16 4:50
     */
    public static void get2(@NonNull RecommendFragment recommendFragment) {

        // 创建Retrofit对象
        Retrofit retrofit = new Retrofit.Builder()
                // 设置 网络请求 Url
                .baseUrl("https://music.163.com/")
                //设置使用Gson解析(记得加入依赖)
                .addConverterFactory(GsonConverterFactory.create())
                // 支持RxJava
                .addCallAdapterFactory(RxJava3CallAdapterFactory.create())
                .build();

        // 创建 网络请求接口 的实例
        GetRequestInterface2 request = retrofit.create(GetRequestInterface2.class);
        // 采用Observable<...>形式 对 网络请求 进行封装
        Observable<PlayListInfo> observable = request.getCall();

        // 发送网络请求
        // 在IO线程进行网络请求
        observable.subscribeOn(Schedulers.io())
                // 回到主线程 处理请求结果
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<PlayListInfo>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                        Log.d(TAG, "开始采用网易云推荐歌单详情接口连接");
                    }

                    @Override
                    public void onNext(@NonNull PlayListInfo result) {
                        RefreshLayout refreshLayout = recommendFragment.getRefreshLayout();
                        // 获取收藏列表
                        CollectManager.readCollect(mp3Infos -> {
                            // 将返回的推荐列表转换为本地音乐信息类列表
                            List<Mp3Info> mp3InfoList = result.cloud2local();
                            // 遍历收藏列表
                            for (Mp3Info mp3Info : mp3Infos) {
                                // 若推荐列表中包含由收藏列表转换的本地音乐信息类列表的本地音乐信息，将推荐列表对应本地音乐信息的isFavourite设为true
                                // 获取包含时的index
                                int index = mp3InfoList.indexOf(mp3Info);
                                if (index != -1) {
                                    mp3InfoList.get(index).setFavorite(true);
                                }
                            }
                            recommendFragment.setList(mp3InfoList);
                            if (refreshLayout != null) {
                                if (refreshLayout.getState() == RefreshState.Refreshing) {
                                    refreshLayout.finishRefresh();
                                } else if (refreshLayout.getState() == RefreshState.Loading) {
                                    refreshLayout.finishLoadMore();
                                }
                            }
                        }, e -> {
                            // 异常处理
                            if (refreshLayout != null) {
                                if (refreshLayout.getState() == RefreshState.Refreshing) {
                                    refreshLayout.finishRefresh(false);
                                } else if (refreshLayout.getState() == RefreshState.Loading) {
                                    refreshLayout.finishLoadMore(false);
                                }
                            }
                        });
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {
                        Log.d(TAG, "请求失败：" + e.getMessage(), e);
                        RefreshLayout refreshLayout = recommendFragment.getRefreshLayout();
                        if (refreshLayout != null) {
                            if (refreshLayout.getState() == RefreshState.Refreshing) {
                                refreshLayout.finishRefresh(false);
                            } else if (refreshLayout.getState() == RefreshState.Loading) {
                                refreshLayout.finishLoadMore(false);
                            }
                        }
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "请求成功");
                    }
                });

    }

    public interface GetRequestInterface3 {
        /**
         * 网易云获取歌词网络请求接口
         *
         * @param id 要获取歌词的歌曲id
         * @return io.reactivex.rxjava3.core.Observable<com.lianyu.wangyiyun.model.Lyric>
         * @author Chen Yuguang
         * @date 2021/5/16 4:48
         */
        @GET("/api/song/lyric?lv=-1&kv=-1&tv=-1")
        Observable<Lyric> getCall(@Query("id") long id);
        // 注解里传入 网络请求 的部分URL地址
        // Retrofit把网络请求的URL分成了两部分：一部分放在Retrofit对象里，另一部分放在网络请求接口里
        // 如果接口里的url是一个完整的网址，那么放在Retrofit对象里的URL可以忽略
        // 采用Observable<...>接口
        // getCall()是接受网络请求数据的方法
    }

    /**
     * 网易云获取歌词网络请求方法
     *
     * @param lyricFragment 歌词视图片段
     * @param id            要获取歌词的歌曲id
     * @author Chen Yuguang
     * @date 2021/5/16 4:50
     */
    public static void get3(LyricFragment lyricFragment, long id) {

        // 创建Retrofit对象
        Retrofit retrofit = new Retrofit.Builder()
                // 设置 网络请求 Url
                .baseUrl("https://music.163.com/")
                //设置使用Gson解析(记得加入依赖)
                .addConverterFactory(GsonConverterFactory.create())
                // 支持RxJava
                .addCallAdapterFactory(RxJava3CallAdapterFactory.create())
                .build();

        // 创建 网络请求接口 的实例
        GetRequestInterface3 request = retrofit.create(GetRequestInterface3.class);
        // 采用Observable<...>形式 对 网络请求 进行封装
        Observable<Lyric> observable = request.getCall(id);

        // 发送网络请求
        // 在IO线程进行网络请求
        observable.subscribeOn(Schedulers.io())
                // 回到主线程 处理请求结果
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<Lyric>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                        Log.d(TAG, "开始采用网易云获取歌词接口连接");
                    }

                    @Override
                    public void onNext(@NonNull Lyric lyric) {
                        // 对返回的数据进行处理
                        Lyric.Lrc lrc = lyric.getLrc();
                        String mainLyric = "", tLyric = "";
                        if (lrc != null) {
                            mainLyric = lrc.getLyric();
                        }
                        Lyric.Tlyric tlyric = lyric.getTlyric();
                        if (tlyric != null) {
                            tLyric = lyric.getTlyric().getLyric();
                        }
                        lyricFragment.updateLyric(mainLyric, tLyric);
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {
                        Log.d(TAG, "请求失败：" + e.getMessage(), e);

                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "请求成功");
                    }
                });

    }

}
